{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "7abeac12",
   "metadata": {},
   "source": [
    "### 初始化环境"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "1beeb749",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 在jupyter notebook里env.render看不到窗口\n",
    "# 写一个helper类，用matplotlib刷新显示图像\n",
    "# 初始化传入env，调用helper的render即可\n",
    "from IPython import display # 导入display模块，用于在Jupyter Notebook中显示图像\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt # 导入matplotlib库，用于绘制图像\n",
    "%matplotlib inline\n",
    "\n",
    "class GymHelper:\n",
    "    def __init__(self, env, figsize = (3, 3)):\n",
    "        self.env = env # 初始化Gym环境\n",
    "        self.figsize = figsize # 初始化绘图窗口大小\n",
    "        \n",
    "        plt.figure(figsize = figsize) # 创建绘图窗口\n",
    "        plt.title(self.env.spec.id) # 标题设为环境名\n",
    "        self.img = plt.imshow(env.render()) # 在绘图窗口中显示初始图像\n",
    "    \n",
    "    def render(self, title = None):\n",
    "        image_data = self.env.render() # 获取当前环境图像渲染数据\n",
    "        \n",
    "        self.img.set_data(image_data) # 更新绘图窗口中的图像数据\n",
    "        display.display(plt.gcf()) # 刷新显示\n",
    "        display.clear_output(wait = True) # 有新图片时再清除绘图窗口原有图像\n",
    "        if title: # 如果有标题，就显示标题\n",
    "            plt.title(title)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ae087b05",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 导入gym库\n",
    "import gym\n",
    "\n",
    "# 创建环境，指定渲染模式为rgb_array，如果是在IDE中可以改为'human'\n",
    "env = gym.make('Acrobot-v1', render_mode='rgb_array')\n",
    "# 重置环境\n",
    "env.reset()\n",
    "# 创建GymHelper\n",
    "gym_helper = GymHelper(env)\n",
    "\n",
    "# 循环N次\n",
    "for i in range(20):\n",
    "    gym_helper.render(title = str(i)) # 渲染环境\n",
    "    action = env.action_space.sample() # 从动作空间中随机选取一个动作\n",
    "    observation, reward, terminated, truncated, info = env.step(action) # 执行动作\n",
    "    if terminated or truncated: # 如果游戏结束，则结束循环\n",
    "        break\n",
    "\n",
    "# 游戏结束\n",
    "gym_helper.render(title = \"Finished\")\n",
    "# 关闭环境\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b777a113",
   "metadata": {},
   "source": [
    "### A2C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9a66a58a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 导入必要的库\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "\n",
    "import numpy as np\n",
    "import sys\n",
    "import time\n",
    "import random\n",
    "import collections\n",
    "from tqdm import * # 用于显示进度条\n",
    "\n",
    "# Actor-Critic网络\n",
    "class ActorCritic(nn.Module):\n",
    "    def __init__(self, input_dim, output_dim):\n",
    "        super(ActorCritic, self).__init__()\n",
    "        \n",
    "        # 使用全连接层构建一个简单的神经网络，共享部分网络层\n",
    "        self.fc1 = nn.Linear(input_dim, 128)\n",
    "        self.fc2 = nn.Linear(128, 128)\n",
    "        \n",
    "        # 分别定义actor和critic对应的全连接层\n",
    "        self.actor = nn.Linear(128, output_dim)\n",
    "        self.critic = nn.Linear(128, 1)\n",
    "\n",
    "    # 定义前向传播\n",
    "    def forward(self, x):\n",
    "        # 使用ReLU函数对前两个全连接层的输出进行变换\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        \n",
    "        # actor网络输出使用softmax函数，得到概率分布\n",
    "        actor_output = F.softmax(self.actor(x), dim = 1)\n",
    "        # critic网络输出，得到给定状态的价值估计\n",
    "        critic_output = self.critic(x)\n",
    "        \n",
    "        # 依次返回对应结果\n",
    "        return actor_output, critic_output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "53f27bed",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A2C算法\n",
    "class A2C:\n",
    "    # 构造函数，参数包含环境，学习率，折扣因子\n",
    "    def __init__(self, env, learning_rate=0.002, gamma=0.99):\n",
    "        self.env = env\n",
    "        self.gamma = gamma\n",
    "\n",
    "        # 判断可用的设备是 CPU 还是 GPU\n",
    "        self.device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "        \n",
    "        # 创建ActorCritic网络，并将模型移动到指定设备上\n",
    "        self.actor_critic = ActorCritic(env.observation_space.shape[0], env.action_space.n).to(self.device)\n",
    "\n",
    "        # 定义Adam优化器\n",
    "        self.optimizer = torch.optim.Adam(self.actor_critic.parameters(), lr=learning_rate)\n",
    "\n",
    "    # 使用模型生成动作概率分布并采样\n",
    "    def choose_action(self, state):\n",
    "        # 将状态转换为tensor输入模型\n",
    "        state = torch.FloatTensor(np.array([state])).to(self.device)\n",
    "        with torch.no_grad():\n",
    "            action_prob, _ = self.actor_critic(state)\n",
    "        \n",
    "        # 生成分布后采样返回动作\n",
    "        c = torch.distributions.Categorical(action_prob)\n",
    "        action = c.sample()\n",
    "        return action.item()\n",
    "    \n",
    "    # 模型更新\n",
    "    def update(self, buffer):\n",
    "        # 取出数据，并将其转换为numpy数组\n",
    "        # 然后进一步转换为tensor，并将数据转移到指定计算资源设备上\n",
    "        states, actions, rewards, next_states, dones = zip(*buffer)\n",
    "        states = torch.FloatTensor(np.array(states)).to(self.device)\n",
    "        actions = torch.tensor(np.array(actions)).view(-1, 1).to(self.device)\n",
    "        rewards = torch.FloatTensor(np.array(rewards)).view(-1, 1).to(self.device)\n",
    "        next_states = torch.FloatTensor(np.array(next_states)).to(self.device)\n",
    "        dones = torch.FloatTensor(np.array(dones)).view(-1, 1).to(self.device)\n",
    "        \n",
    "        # 计算TD目标及误差\n",
    "        action_prob, state_value = self.actor_critic(states)\n",
    "        _, next_state_value = self.actor_critic(next_states)\n",
    "        td_target = rewards + (1 - dones) * self.gamma * next_state_value\n",
    "        td_delta = td_target - state_value\n",
    "        \n",
    "        # 计算动作概率的对数\n",
    "        log_prob = torch.log(action_prob.gather(1, actions))\n",
    "\n",
    "        # 计算actor和critic的loss\n",
    "        actor_loss = -(log_prob * td_delta.detach()).mean()\n",
    "        critic_loss = F.mse_loss(state_value, td_target).mean()\n",
    "        # 总loss设为actor_loss和critic_loss的加权和\n",
    "        loss = actor_loss + critic_loss * 0.5\n",
    "\n",
    "        # 梯度清零、反向传播、更新参数\n",
    "        self.optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        self.optimizer.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "be693ccb",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode 0: -500.0                      \n",
      "Episode 30: -500.0                              \n",
      "Episode 60: -496.0                              \n",
      "Episode 90: -149.0                              \n",
      "Episode 120: -170.0                              \n",
      "Episode 150: -114.0                              \n",
      "Episode 180: -115.0                              \n",
      "Episode 210: -95.0                               \n",
      "Episode 240: -73.0                               \n",
      "Episode 270: -76.0                               \n",
      "100%|██████████| 300/300 [00:22<00:00, 13.34it/s]\n"
     ]
    }
   ],
   "source": [
    "# 定义超参数\n",
    "max_episodes = 300 # 训练episode数\n",
    "\n",
    "# 创建A2C对象\n",
    "agent = A2C(env)\n",
    "# 定义保存每个回合奖励的列表\n",
    "episode_rewards = []\n",
    "\n",
    "# 开始循环，tqdm用于显示进度条并评估任务时间开销\n",
    "for episode in tqdm(range(max_episodes), file=sys.stdout):\n",
    "    # 重置环境并获取初始状态\n",
    "    state, _ = env.reset()\n",
    "    # 当前回合的奖励\n",
    "    episode_reward = 0\n",
    "    # 记录每个episode的信息\n",
    "    buffer = []\n",
    "\n",
    "    # 循环进行每一步操作\n",
    "    while 1:\n",
    "        # 根据当前状态选择动作\n",
    "        action = agent.choose_action(state)\n",
    "        # 执行动作，获取新的信息\n",
    "        next_state, reward, terminated, truncated, info = env.step(action)\n",
    "        # 判断是否达到终止状态\n",
    "        done = terminated or truncated\n",
    "        \n",
    "        # 将这个五元组加到buffer中\n",
    "        buffer.append((state, action, reward, next_state, done))\n",
    "        # 累计奖励\n",
    "        episode_reward += reward\n",
    "        \n",
    "        # 更新当前状态\n",
    "        state = next_state\n",
    "\n",
    "        if done:\n",
    "            break\n",
    "    \n",
    "    # 更新策略\n",
    "    agent.update(buffer)\n",
    "    # 记录当前回合奖励值\n",
    "    episode_rewards.append(episode_reward)\n",
    "    \n",
    "    # 打印中间值\n",
    "    if episode % (max_episodes // 10) == 0:\n",
    "        tqdm.write(\"Episode \" + str(episode) + \": \" + str(episode_reward))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "65aa7cb1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 使用Matplotlib绘制奖励值的曲线图\n",
    "plt.plot(episode_rewards)\n",
    "plt.title(\"reward\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "57d9e250",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 重置环境，开始新的一轮游戏\n",
    "observation, _ = env.reset()\n",
    "# 创建GymHelper对象来辅助显示\n",
    "gym_helper = GymHelper(env, figsize = (3, 3))\n",
    "\n",
    "# 开始游戏\n",
    "for i in range(500):\n",
    "    # 渲染环境，title为当前步骤数\n",
    "    gym_helper.render(title = str(i))\n",
    "    \n",
    "    # 找到当前状态下的最优动作\n",
    "    action = agent.choose_action(observation)\n",
    "    # 执行action，获取新的信息\n",
    "    observation, reward, terminated, truncated, info = env.step(action)\n",
    "    \n",
    "    # 如果游戏结束，则结束当前循环\n",
    "    if terminated or truncated:\n",
    "        break\n",
    "\n",
    "# 游戏结束\n",
    "gym_helper.render(title = \"Finished\")\n",
    "# 关闭环境\n",
    "env.close()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
